/**
 * Created by Administrator on 15-10-14.
 */
/**
 * Bounce.js 0.8.2
 * MIT license
 */
!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Bounce=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
    var Component, EasingClasses, Matrix4D;

    Matrix4D = _dereq_("../math/matrix4d");

    EasingClasses = {
        bounce: _dereq_("../easing/bounce"),
        sway: _dereq_("../easing/sway"),
        hardbounce: _dereq_("../easing/hardbounce"),
        hardsway: _dereq_("../easing/hardsway")
    };

    Component = (function() {
        Component.prototype.easing = "bounce";

        Component.prototype.duration = 5000;

        Component.prototype.delay = 0;

        Component.prototype.from = null;

        Component.prototype.to = null;

        function Component(options) {
            options || (options = {});
            if (options.easing != null) {
                this.easing = options.easing;
            }
            if (options.duration != null) {
                this.duration = options.duration;
            }
            if (options.delay != null) {
                this.delay = options.delay;
            }
            if (options.from != null) {
                this.from = options.from;
            }
            if (options.to != null) {
                this.to = options.to;
            }
            this.easingObject = new EasingClasses[this.easing](options);
        }

        Component.prototype.calculateEase = function(ratio) {
            return this.easingObject.calculate(ratio);
        };

        Component.prototype.getMatrix = function() {
            return new Matrix4D().identity();
        };

        Component.prototype.getEasedMatrix = function(ratio) {
            return this.getMatrix();
        };

        Component.prototype.serialize = function() {
            var key, serialized, value, _ref;
            serialized = {
                type: this.constructor.name.toLowerCase(),
                easing: this.easing,
                duration: this.duration,
                delay: this.delay,
                from: this.from,
                to: this.to
            };
            _ref = this.easingObject.serialize();
            for (key in _ref) {
                value = _ref[key];
                serialized[key] = value;
            }
            return serialized;
        };

        return Component;

    })();

    module.exports = Component;


},{"../easing/bounce":6,"../easing/hardbounce":7,"../easing/hardsway":8,"../easing/sway":10,"../math/matrix4d":13}],2:[function(_dereq_,module,exports){
    var Component, Matrix4D, Rotate, Vector2D,
        __hasProp = {}.hasOwnProperty,
        __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

    Matrix4D = _dereq_("../math/matrix4d");

    Vector2D = _dereq_("../math/vector2d");

    Component = _dereq_("./index");

    Rotate = (function(_super) {
        __extends(Rotate, _super);

        Rotate.prototype.from = 0;

        Rotate.prototype.to = 90;


        function Rotate() {
            Rotate.__super__.constructor.apply(this, arguments);
            this.diff = this.to - this.from;
        }

        Rotate.prototype.getMatrix = function(degrees) {
            var c, radians, s;
            radians = (degrees / 180) * Math.PI;
            c = Math.cos(radians);
            s = Math.sin(radians);
            return new Matrix4D([c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
        };

        Rotate.prototype.getEasedMatrix = function(ratio) {
            var easedAngle, easedRatio;
            easedRatio = this.calculateEase(ratio);
            easedAngle = this.from + this.diff * easedRatio;
            return this.getMatrix(easedAngle);
        };

        return Rotate;

    })(Component);

    module.exports = Rotate;


},{"../math/matrix4d":13,"../math/vector2d":14,"./index":1}],3:[function(_dereq_,module,exports){
    var Component, Matrix4D, Scale, Vector2D,
        __hasProp = {}.hasOwnProperty,
        __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

    Matrix4D = _dereq_("../math/matrix4d");

    Vector2D = _dereq_("../math/vector2d");

    Component = _dereq_("./index");

    Scale = (function(_super) {
        __extends(Scale, _super);

        Scale.prototype.from = {
            x: 0.5,
            y: 0.5
        };

        Scale.prototype.to = {
            x: 1,
            y: 1
        };

        function Scale() {
            Scale.__super__.constructor.apply(this, arguments);
            this.fromVector = new Vector2D(this.from.x, this.from.y);
            this.toVector = new Vector2D(this.to.x, this.to.y);
            this.diff = this.toVector.clone().subtract(this.fromVector);
        }

        Scale.prototype.getMatrix = function(x, y) {
            var z;
            z = 1;
            return new Matrix4D([x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1]);
        };

        Scale.prototype.getEasedMatrix = function(ratio) {
            var easedRatio, easedVector;
            easedRatio = this.calculateEase(ratio);
            easedVector = this.fromVector.clone().add(this.diff.clone().multiply(easedRatio));
            return this.getMatrix(easedVector.x, easedVector.y);
        };

        return Scale;

    })(Component);

    module.exports = Scale;


},{"../math/matrix4d":13,"../math/vector2d":14,"./index":1}],4:[function(_dereq_,module,exports){
    var Component, Matrix4D, Skew, Vector2D,
        __hasProp = {}.hasOwnProperty,
        __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

    Matrix4D = _dereq_("../math/matrix4d");

    Vector2D = _dereq_("../math/vector2d");

    Component = _dereq_("./index");

    Skew = (function(_super) {
        __extends(Skew, _super);

        Skew.prototype.from = {
            x: 0,
            y: 0
        };

        Skew.prototype.to = {
            x: 20,
            y: 0
        };

        function Skew() {
            Skew.__super__.constructor.apply(this, arguments);
            this.fromVector = new Vector2D(this.from.x, this.from.y);
            this.toVector = new Vector2D(this.to.x, this.to.y);
            this.diff = this.toVector.clone().subtract(this.fromVector);
        }

        Skew.prototype.getMatrix = function(degreesX, degreesY) {
            var radiansX, radiansY, tx, ty;
            radiansX = (degreesX / 180) * Math.PI;
            radiansY = (degreesY / 180) * Math.PI;
            tx = Math.tan(radiansX);
            ty = Math.tan(radiansY);
            return new Matrix4D([1, tx, 0, 0, ty, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
        };

        Skew.prototype.getEasedMatrix = function(ratio) {
            var easedRatio, easedVector;
            easedRatio = this.calculateEase(ratio);
            easedVector = this.fromVector.clone().add(this.diff.clone().multiply(easedRatio));
            return this.getMatrix(easedVector.x, easedVector.y);
        };

        return Skew;

    })(Component);

    module.exports = Skew;


},{"../math/matrix4d":13,"../math/vector2d":14,"./index":1}],5:[function(_dereq_,module,exports){
    var Component, Matrix4D, Translate, Vector2D,
        __hasProp = {}.hasOwnProperty,
        __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

    Matrix4D = _dereq_("../math/matrix4d");

    Vector2D = _dereq_("../math/vector2d");

    Component = _dereq_("./index");

    Translate = (function(_super) {
        __extends(Translate, _super);

        Translate.prototype.from = {
            x: 0,
            y: 0
        };

        Translate.prototype.to = {
            x: 0,
            y: 0
        };

        function Translate() {
            Translate.__super__.constructor.apply(this, arguments);
            this.fromVector = new Vector2D(this.from.x, this.from.y);
            this.toVector = new Vector2D(this.to.x, this.to.y);
            this.diff = this.toVector.clone().subtract(this.fromVector);
        }

        Translate.prototype.getMatrix = function(x, y) {
            var z;
            z = 0;
            return new Matrix4D([1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1]);
        };

        Translate.prototype.getEasedMatrix = function(ratio) {
            var easedRatio, easedVector;
            easedRatio = this.calculateEase(ratio);
            easedVector = this.fromVector.clone().add(this.diff.clone().multiply(easedRatio));
            return this.getMatrix(easedVector.x, easedVector.y);
        };

        return Translate;

    })(Component);

    module.exports = Translate;


},{"../math/matrix4d":13,"../math/vector2d":14,"./index":1}],6:[function(_dereq_,module,exports){
    var BounceEasing, Easing,
        __hasProp = {}.hasOwnProperty,
        __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

    Easing = _dereq_("./index");

    BounceEasing = (function(_super) {
        __extends(BounceEasing, _super);

        BounceEasing.prototype.bounces = 4;

        BounceEasing.prototype.stiffness = 3;

        function BounceEasing(options) {
            var threshold;
            if (options == null) {
                options = {};
            }
            BounceEasing.__super__.constructor.apply(this, arguments);
            if (options.stiffness != null) {
                this.stiffness = options.stiffness;
            }
            if (options.bounces != null) {
                this.bounces = options.bounces;
            }
            this.alpha = this.stiffness / 100;
            threshold = 0.005 / Math.pow(10, this.stiffness);
            this.limit = Math.floor(Math.log(threshold) / -this.alpha);
            this.omega = this.calculateOmega(this.bounces, this.limit);
        }

        BounceEasing.prototype.calculate = function(ratio) {
            var t;
            if (ratio >= 1) {
                return 1;
            }
            t = ratio * this.limit;
            return 1 - this.exponent(t) * this.oscillation(t);
        };

        BounceEasing.prototype.calculateOmega = function(bounces, limit) {
            return (this.bounces + 0.5) * Math.PI / this.limit;
        };

        BounceEasing.prototype.exponent = function(t) {
            return Math.pow(Math.E, -this.alpha * t);
        };

        BounceEasing.prototype.oscillation = function(t) {
            return Math.cos(this.omega * t);
        };

        BounceEasing.prototype.serialize = function() {
            return {
                stiffness: this.stiffness,
                bounces: this.bounces
            };
        };

        return BounceEasing;

    })(Easing);

    module.exports = BounceEasing;


},{"./index":9}],7:[function(_dereq_,module,exports){
    var BounceEasing, HardBounceEasing,
        __hasProp = {}.hasOwnProperty,
        __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

    BounceEasing = _dereq_("./bounce");

    HardBounceEasing = (function(_super) {
        __extends(HardBounceEasing, _super);

        function HardBounceEasing() {
            return HardBounceEasing.__super__.constructor.apply(this, arguments);
        }

        HardBounceEasing.prototype.oscillation = function(t) {
            return Math.abs(Math.cos(this.omega * t));
        };

        return HardBounceEasing;

    })(BounceEasing);

    module.exports = HardBounceEasing;


},{"./bounce":6}],8:[function(_dereq_,module,exports){
    var HardSwayEasing, SwayEasing,
        __hasProp = {}.hasOwnProperty,
        __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

    SwayEasing = _dereq_("./sway");

    HardSwayEasing = (function(_super) {
        __extends(HardSwayEasing, _super);

        function HardSwayEasing() {
            return HardSwayEasing.__super__.constructor.apply(this, arguments);
        }

        HardSwayEasing.prototype.oscillation = function(t) {
            return Math.abs(Math.sin(this.omega * t));
        };

        return HardSwayEasing;

    })(SwayEasing);

    module.exports = HardSwayEasing;


},{"./sway":10}],9:[function(_dereq_,module,exports){
    var Easing, MathHelpers;

    MathHelpers = _dereq_("../math/helpers");

    Easing = (function() {
        function Easing() {}

        Easing.prototype.calculate = function(ratio) {
            return ratio;
        };

        Easing.prototype.serialize = function() {
            return {};
        };

        Easing.prototype.findOptimalKeyPoints = function(threshold, resolution) {
            var area, halfway, i, keyPoint, keyPoints, loops, result, values;
            if (threshold == null) {
                threshold = 1.0;
            }
            if (resolution == null) {
                resolution = 1000;
            }
            keyPoints = [0];
            values = (function() {
                var _i, _results;
                _results = [];
                for (i = _i = 0; 0 <= resolution ? _i < resolution : _i > resolution; i = 0 <= resolution ? ++_i : --_i) {
                    _results.push(this.calculate(i / resolution));
                }
                return _results;
            }).call(this);
            keyPoints = keyPoints.concat(MathHelpers.findTurningPoints(values));
            keyPoints.push(resolution - 1);
            i = 0;
            loops = 1000;
            while (loops--) {
                if (i === keyPoints.length - 1) {
                    break;
                }
                area = MathHelpers.areaBetweenLineAndCurve(values, keyPoints[i], keyPoints[i + 1]);
                if (area <= threshold) {
                    i++;
                } else {
                    halfway = Math.round(keyPoints[i] + (keyPoints[i + 1] - keyPoints[i]) / 2);
                    keyPoints.splice(i + 1, 0, halfway);
                }
            }
            if (loops === 0) {
                return [];
            }
            return result = (function() {
                var _i, _len, _results;
                _results = [];
                for (_i = 0, _len = keyPoints.length; _i < _len; _i++) {
                    keyPoint = keyPoints[_i];
                    _results.push(keyPoint / (resolution - 1));
                }
                return _results;
            })();
        };

        return Easing;

    })();

    module.exports = Easing;


},{"../math/helpers":12}],10:[function(_dereq_,module,exports){
    var BounceEasing, SwayEasing,
        __hasProp = {}.hasOwnProperty,
        __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

    BounceEasing = _dereq_("./bounce");

    SwayEasing = (function(_super) {
        __extends(SwayEasing, _super);

        function SwayEasing() {
            return SwayEasing.__super__.constructor.apply(this, arguments);
        }

        SwayEasing.prototype.calculate = function(ratio) {
            var t;
            if (ratio >= 1) {
                return 0;
            }
            t = ratio * this.limit;
            return this.exponent(t) * this.oscillation(t);
        };

        SwayEasing.prototype.calculateOmega = function(bounces, limit) {
            return this.bounces * Math.PI / this.limit;
        };

        SwayEasing.prototype.oscillation = function(t) {
            return Math.sin(this.omega * t);
        };

        return SwayEasing;

    })(BounceEasing);

    module.exports = SwayEasing;


},{"./bounce":6}],11:[function(_dereq_,module,exports){
    var Bounce, ComponentClasses, Matrix4D;

    Matrix4D = _dereq_("./math/matrix4d");

    ComponentClasses = {
        scale: _dereq_("./components/scale"),
        rotate: _dereq_("./components/rotate"),
        translate: _dereq_("./components/translate"),
        skew: _dereq_("./components/skew")
    };

    Bounce = (function() {
        Bounce.FPS = 30;

        Bounce.counter = 1;

        Bounce.prototype.components = null;

        Bounce.prototype.duration = 0;

        function Bounce() {
            this.components = [];
        }

        Bounce.prototype.scale = function(options) {
            return this.addComponent(new ComponentClasses["scale"](options));
        };

        Bounce.prototype.rotate = function(options) {
            return this.addComponent(new ComponentClasses["rotate"](options));
        };

        Bounce.prototype.translate = function(options) {
            return this.addComponent(new ComponentClasses["translate"](options));
        };

        Bounce.prototype.skew = function(options) {
            return this.addComponent(new ComponentClasses["skew"](options));
        };

        Bounce.prototype.addComponent = function(component) {
            this.components.push(component);
            this.updateDuration();
            return this;
        };

        Bounce.prototype.serialize = function() {
            var component, serialized, _i, _len, _ref;
            serialized = [];
            _ref = this.components;
            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
                component = _ref[_i];
                serialized.push(component.serialize());
            }
            return serialized;
        };

        Bounce.prototype.deserialize = function(serialized) {
            var options, _i, _len;
            for (_i = 0, _len = serialized.length; _i < _len; _i++) {
                options = serialized[_i];
                this.addComponent(new ComponentClasses[options.type](options));
            }
            return this;
        };

        Bounce.prototype.updateDuration = function() {
            return this.duration = this.components.map(function(component) {
                return component.duration + component.delay;
            }).reduce(function(a, b) {
                    return Math.max(a, b);
                });
        };

        Bounce.prototype.define = function(name) {
            this.name = name || Bounce.generateName();
            this.styleElement = document.createElement("style");
            this.styleElement.innerHTML = this.getKeyframeCSS({
                name: this.name,
                prefix: true
            });
            document.body.appendChild(this.styleElement);
            return this;
        };

        Bounce.prototype.applyTo = function(elements, options) {
            var css, deferred, element, prefix, prefixes, _i, _j, _len, _len1, _ref;
            if (options == null) {
                options = {};
            }
            this.define();
            if (!elements.length) {
                elements = [elements];
            }
            prefixes = this.getPrefixes();
            deferred = null;
            if (window.jQuery && window.jQuery.Deferred) {
                deferred = new window.jQuery.Deferred();
            }
            for (_i = 0, _len = elements.length; _i < _len; _i++) {
                element = elements[_i];
                _ref = prefixes.animation;
                for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
                    prefix = _ref[_j];
                    css = [this.name, "" + this.duration + "ms", "linear", "both"];
                    if (options.loop) {
                        css.push("infinite");
                    }
                    element.style["" + prefix + "animation"] = css.join(" ");
                }
            }
            if (!options.loop) {
                console.log(options);
                setTimeout(((function(_this) {
                    return function() {
                        if (options.remove) {
                            _this.remove();
                        }
                        if (typeof options.onComplete === "function") {
                            options.onComplete();
                        }
                        if (deferred) {
                            return deferred.resolve();
                        }
                    };
                })(this)), this.duration);
            }
            return deferred;
        };

        Bounce.prototype.remove = function() {
            var _ref;
            if (!this.styleElement) {
                return;
            }
            if (this.styleElement.remove) {
                return this.styleElement.remove();
            } else {
                return (_ref = this.styleElement.parentNode) != null ? _ref.removeChild(this.styleElement) : void 0;
            }
        };

        Bounce.prototype.getPrefixes = function(force) {
            var prefixes, style;
            prefixes = {
                transform: [""],
                animation: [""]
            };
            style = document.createElement("dummy").style;
            if (force || (!("transform" in style) && "webkitTransform" in style)) {
                prefixes.transform = ["-webkit-", ""];
            }
            if (force || (!("animation" in style) && "webkitAnimation" in style)) {
                prefixes.animation = ["-webkit-", ""];
            }
            return prefixes;
        };

        Bounce.prototype.getKeyframeCSS = function(options) {
            var animations, key, keyframeList, keyframes, matrix, prefix, prefixes, transformString, transforms, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2;
            if (options == null) {
                options = {};
            }
            this.name = options.name || Bounce.generateName();
            prefixes = {
                transform: [""],
                animation: [""]
            };
            if (options.prefix || options.forcePrefix) {
                prefixes = this.getPrefixes(options.forcePrefix);
            }
            keyframeList = [];
            keyframes = this.getKeyframes(options);
            _ref = this.keys;
            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
                key = _ref[_i];
                matrix = keyframes[key];
                transformString = "matrix3d" + matrix;
                transforms = [];
                _ref1 = prefixes.transform;
                for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
                    prefix = _ref1[_j];
                    transforms.push("" + prefix + "transform: " + transformString + ";");
                }
                keyframeList.push("" + (Math.round(key * 100 * 100) / 100) + "% { " + (transforms.join(" ")) + " }");
            }
            animations = [];
            _ref2 = prefixes.animation;
            for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
                prefix = _ref2[_k];
                animations.push("@" + prefix + "keyframes " + this.name + " { \n  " + (keyframeList.join("\n  ")) + " \n}");
            }
            return animations.join("\n\n");
        };

        Bounce.prototype.getKeyframes = function(options) {
            var component, componentKeys, currentTime, frames, i, key, keyframes, keys, matrix, ratio, _i, _j, _k, _l, _len, _len1, _len2, _ref, _ref1;
            if (options == null) {
                options = {};
            }
            keys = [0, 1];
            if (options.optimized) {
                _ref = this.components;
                for (_i = 0, _len = _ref.length; _i < _len; _i++) {
                    component = _ref[_i];
                    componentKeys = component.easingObject.findOptimalKeyPoints().map((function(_this) {
                        return function(key) {
                            return (key * component.duration / _this.duration) + (component.delay / _this.duration);
                        };
                    })(this));
                    if (component.delay) {
                        componentKeys.push((component.delay / this.duration) - 0.001);
                    }
                    keys = keys.concat(componentKeys);
                }
            } else {
                frames = Math.round((this.duration / 1000) * Bounce.FPS);
                for (i = _j = 0; 0 <= frames ? _j <= frames : _j >= frames; i = 0 <= frames ? ++_j : --_j) {
                    keys.push(i / frames);
                }
            }
            keys = keys.sort(function(a, b) {
                return a - b;
            });
            this.keys = [];
            keyframes = {};
            for (_k = 0, _len1 = keys.length; _k < _len1; _k++) {
                key = keys[_k];
                if (keyframes[key]) {
                    continue;
                }
                matrix = new Matrix4D().identity();
                _ref1 = this.components;
                for (_l = 0, _len2 = _ref1.length; _l < _len2; _l++) {
                    component = _ref1[_l];
                    currentTime = key * this.duration;
                    if ((component.delay - currentTime) > 1e-8) {
                        continue;
                    }
                    ratio = (key - component.delay / this.duration) / (component.duration / this.duration);
                    matrix.multiply(component.getEasedMatrix(ratio));
                }
                this.keys.push(key);
                keyframes[key] = matrix.transpose().toFixed(3);
            }
            return keyframes;
        };

        Bounce.generateName = function() {
            return "animation-" + (Bounce.counter++);
        };

        Bounce.isSupported = function() {
            var property, propertyIsSupported, propertyList, propertyLists, style, _i, _j, _len, _len1;
            style = document.createElement("dummy").style;
            propertyLists = [["transform", "webkitTransform"], ["animation", "webkitAnimation"]];
            for (_i = 0, _len = propertyLists.length; _i < _len; _i++) {
                propertyList = propertyLists[_i];
                propertyIsSupported = false;
                for (_j = 0, _len1 = propertyList.length; _j < _len1; _j++) {
                    property = propertyList[_j];
                    propertyIsSupported || (propertyIsSupported = property in style);
                }
                if (!propertyIsSupported) {
                    return false;
                }
            }
            return true;
        };

        return Bounce;

    })();

    module.exports = Bounce;


},{"./components/rotate":2,"./components/scale":3,"./components/skew":4,"./components/translate":5,"./math/matrix4d":13}],12:[function(_dereq_,module,exports){
    var MathHelpers;

    MathHelpers = (function() {
        function MathHelpers() {}

        MathHelpers.prototype.sign = function(value) {
            if (value < 0) {
                return -1;
            }
            return 1;
        };

        MathHelpers.prototype.findTurningPoints = function(values) {
            var i, signA, signB, turningPoints, _i, _ref;
            turningPoints = [];
            for (i = _i = 1, _ref = values.length - 1; 1 <= _ref ? _i < _ref : _i > _ref; i = 1 <= _ref ? ++_i : --_i) {
                signA = this.sign(values[i] - values[i - 1]);
                signB = this.sign(values[i + 1] - values[i]);
                if (signA !== signB) {
                    turningPoints.push(i);
                }
            }
            return turningPoints;
        };

        MathHelpers.prototype.areaBetweenLineAndCurve = function(values, start, end) {
            var area, curveValue, i, length, lineValue, yEnd, yStart, _i;
            length = end - start;
            yStart = values[start];
            yEnd = values[end];
            area = 0;
            for (i = _i = 0; 0 <= length ? _i <= length : _i >= length; i = 0 <= length ? ++_i : --_i) {
                curveValue = values[start + i];
                lineValue = yStart + (i / length) * (yEnd - yStart);
                area += Math.abs(lineValue - curveValue);
            }
            return area;
        };

        return MathHelpers;

    })();

    module.exports = new MathHelpers;


},{}],13:[function(_dereq_,module,exports){
    var Matrix4D;

    Matrix4D = (function() {
        Matrix4D.prototype._array = null;

        function Matrix4D(array) {
            this._array = (array != null ? array.slice(0) : void 0) || [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
        }

        Matrix4D.prototype.equals = function(matrix) {
            return this.toString() === matrix.toString();
        };

        Matrix4D.prototype.identity = function() {
            this.setArray([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
            return this;
        };

        Matrix4D.prototype.multiply = function(matrix) {
            var i, j, k, res, value, _i, _j, _k;
            res = new Matrix4D;
            for (i = _i = 0; _i < 4; i = ++_i) {
                for (j = _j = 0; _j < 4; j = ++_j) {
                    for (k = _k = 0; _k < 4; k = ++_k) {
                        value = res.get(i, j) + this.get(i, k) * matrix.get(k, j);
                        res.set(i, j, value);
                    }
                }
            }
            return this.copy(res);
        };

        Matrix4D.prototype.transpose = function() {
            var a;
            a = this.getArray();
            this.setArray([a[0], a[4], a[8], a[12], a[1], a[5], a[9], a[13], a[2], a[6], a[10], a[14], a[3], a[7], a[11], a[15]]);
            return this;
        };

        Matrix4D.prototype.get = function(row, column) {
            return this.getArray()[row * 4 + column];
        };

        Matrix4D.prototype.set = function(row, column, value) {
            return this._array[row * 4 + column] = value;
        };

        Matrix4D.prototype.copy = function(matrix) {
            this._array = matrix.getArray();
            return this;
        };

        Matrix4D.prototype.clone = function() {
            return new Matrix4D(this.getArray());
        };

        Matrix4D.prototype.getArray = function() {
            return this._array.slice(0);
        };

        Matrix4D.prototype.setArray = function(array) {
            this._array = array;
            return this;
        };

        Matrix4D.prototype.toString = function() {
            return "(" + (this.getArray().join(", ")) + ")";
        };

        Matrix4D.prototype.toFixed = function(n) {
            var value;
            this._array = (function() {
                var _i, _len, _ref, _results;
                _ref = this._array;
                _results = [];
                for (_i = 0, _len = _ref.length; _i < _len; _i++) {
                    value = _ref[_i];
                    _results.push(parseFloat(value.toFixed(n)));
                }
                return _results;
            }).call(this);
            return this;
        };

        return Matrix4D;

    })();

    module.exports = Matrix4D;


},{}],14:[function(_dereq_,module,exports){
    var Vector2D;

    Vector2D = (function() {
        Vector2D.prototype.x = 0;

        Vector2D.prototype.y = 0;

        function Vector2D(x, y) {
            this.x = x != null ? x : 0;
            this.y = y != null ? y : 0;
        }

        Vector2D.prototype.add = function(vector) {
            if (!Vector2D.isVector2D(vector)) {
                return this._addScalar(vector);
            }
            this.x += vector.x;
            this.y += vector.y;
            return this;
        };

        Vector2D.prototype._addScalar = function(n) {
            this.x += n;
            this.y += n;
            return this;
        };

        Vector2D.prototype.subtract = function(vector) {
            if (!Vector2D.isVector2D(vector)) {
                return this._subtractScalar(vector);
            }
            this.x -= vector.x;
            this.y -= vector.y;
            return this;
        };

        Vector2D.prototype._subtractScalar = function(n) {
            return this._addScalar(-n);
        };

        Vector2D.prototype.multiply = function(vector) {
            if (!Vector2D.isVector2D(vector)) {
                return this._multiplyScalar(vector);
            }
            this.x *= vector.x;
            this.y *= vector.y;
            return this;
        };

        Vector2D.prototype._multiplyScalar = function(n) {
            this.x *= n;
            this.y *= n;
            return this;
        };

        Vector2D.prototype.divide = function(vector) {
            if (!Vector2D.isVector2D(vector)) {
                return this._divideScalar(vector);
            }
            this.x /= vector.x;
            this.y /= vector.y;
            return this;
        };

        Vector2D.prototype._divideScalar = function(n) {
            return this._multiplyScalar(1 / n);
        };

        Vector2D.prototype.clone = function() {
            return new Vector2D(this.x, this.y);
        };

        Vector2D.prototype.copy = function(vector) {
            this.x = vector.x;
            this.y = vector.y;
            return this;
        };

        Vector2D.prototype.equals = function(vector) {
            return vector.x === this.x && vector.y === this.y;
        };

        Vector2D.prototype.toString = function() {
            return "(" + this.x + ", " + this.y + ")";
        };

        Vector2D.prototype.toFixed = function(n) {
            this.x = parseFloat(this.x.toFixed(n));
            this.y = parseFloat(this.y.toFixed(n));
            return this;
        };

        Vector2D.prototype.toArray = function() {
            return [this.x, this.y];
        };

        Vector2D.isVector2D = function(item) {
            return item instanceof Vector2D;
        };

        return Vector2D;

    })();

    module.exports = Vector2D;


},{}]},{},[11])
    (11)
});